A number of monitoring and display systems have been developed for parallel computer systems. They tend to be used for performance analysis and tuning, or for debugging.
Most of the performance-oriented systems focus solely on the global behavior of the computer system. They display such phenomena as parallelism over time or communication and synchronization over time. Often they display timelines, showing interesting events. These events are either declared explicitly in the program by the user, or are recognized occurrences in the underlying operating system or support library. A few of these systems display code, and allow a user to click on some part of an interesting global display and have the corresponding part of the code highlighted (i.e. the code which was being executed at the time). Some of these systems display more global program structure in some form other than code, such as directed graphs, and then color these structures dynamically to show which program components are active.
A number of these systems display strictly quantitative data concerning performance, rather than trying to present animated displays reflecting the actual behavior of the parallel computer system.
Systems oriented towards debugging tend to either abstract away the details of parallel execution into higher-level events, or to focus on the state and progress of one individual processor at a time.
However, none of these systems displays the program code as the static entity that it truly is nor do these systems try to give the user a feel for how the processors range back and forth over the lines of code while executing the program.
User understanding of the dynamics of how the various processors move over (execute) the code, and how the processors that are executing the code relate to each other can be crucial to understanding the overall (mis)behavior of the parallel computer system. In many cases, performance problems in parallel computer systems arise from the processors getting out of step in the execution of the single program code. In other cases, a single processor exhibits an erratic pattern compared to all of the rest of the processors, resulting in large delays for the system as a whole.